<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-us" lang="en-us">
<head>
  <link href="https://gmpg.org/xfn/11" rel="profile">
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <meta name="generator" content="Hugo 0.68.3" />

  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <title>第三篇文章 &middot; 我的博客</title>
  <meta name="description" content="" />

  
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/print.css" media="print">
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/poole.css">
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/syntax.css">
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/hyde.css">
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Abril+Fatface|PT+Sans:400,400i,700">


  
  <link rel="apple-touch-icon-precomposed" sizes="144x144" href="/apple-touch-icon-144-precomposed.png">
  <link rel="shortcut icon" href="/favicon.png">

  
  
</head>

  <body class="theme-base-0self ">
  <aside class="sidebar">
  <div class="container sidebar-sticky">
    <div class="sidebar-about">
      <a href="/my_technology_blog/"><h1>我的博客</h1></a>
      <p class="lead">
       这里是田帅康的个人博客 
      </p>
    </div>

    <nav>
      <ul class="sidebar-nav">
        <li><a href="/my_technology_blog/">Home</a> </li>
        
      </ul>
    </nav>

    <p>&copy; 2020. All rights reserved. </p>
  </div>
</aside>

    <main class="content container">
    <div class="post">
  <h1>第三篇文章</h1>
  <time datetime=2020-04-08T00:00:00Z class="post-date">Wed, Apr 8, 2020</time>
  <h2 id="进程-线程-协程">进程 线程 协程</h2>
<p>进程，是执行中的计算机程序。也就是说，每个代码在执行的时候，首先本身即是一个进程 <br>
一个进程具有:就绪，运行，中断，僵死，结束等状态(不同操作系统不一样)</p>
<h3 id="并行">并行</h3>
<p>同一个CPU上，可以运行多个进程，由操作系统来自动分配时间片<br>
由于进程间资源不能共享，需要进程间通信，来发送数据，接受消息等
多进程，也称为“并行”</p>
<h3 id="进程间通信">进程间通信</h3>
<p>进程彼此之间互相隔离，要实现进程间通信（IPC）<br>
multiprocessing模块支持两种形式：队列和管道</p>
<h2 id="进程池">进程池</h2>
<h3 id="概念上来理解">概念上来理解：</h3>
<p>在Python中，拥有着独特的进程生成器：进程池。当进程足够多，已经多到无法人为去手动创建时，进程池就被应运而生<br>
使用多进程是为了并发，通常有几个cpu核心就开几个进程，但是进程开多了会影响效率，
主要体现在切换的开销，所以引入进程池限制进程的数量。</p>
<h2 id="线程">线程</h2>
<p>线程，是在进程中执行的代码。<br>
一个进程下可以运行多个线程，这些线程之间共享主进程内申请的操作系统资源。
特性:
线程，必须在一个存在的进程中启动运行</p>
<h3 id="进程和线程的区别">进程和线程的区别</h3>
<p>一个进程中的各个线程与主进程共享相同的资源，与进程间互相独立相比，线程之间信息共享和通信更加容易(都在进程中，并且共享内存等)。<br>
线程一般以并发执行，正是由于这种并发和数据共享机制，使多任务间的协作成为可能</p>
<h2 id="协程">协程</h2>
<p>协程: 协程，又称微线程，纤程，英文名Coroutine。协程的作用，是在执行函数A时，可以随时中断，<br>
去执行函数B，然后中断继续执行函数A（可以自由切换）</p>
<h3 id="协程优点">协程优点：</h3>
<p>1.协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级<br>
2.单线程内就可以实现并发的效果，最大限度地利用cpu</p>
<h3 id="协程缺点">协程缺点：</h3>
<p>1.无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.<br>
当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用
2.协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程</p>
<h2 id="四大高阶函数">四大高阶函数</h2>
<h3 id="map">map</h3>
<p>一般情况map()函数接收两个参数，一个函数（该函数接收一个参数），一个序列，将传入的函数依次作用到序列的每个元素，<br>
并返回一个新的Iterator（迭代器）。</p>
<h3 id="reduce">reduce</h3>
<p>和map()用法类似，reduce把传入的函数作用在一个序列上，但传入的函数需要接收两个参数，<br>
传入函数的计算结果继续和序列的下一个元素做累积计算</p>
<h3 id="filter">filter</h3>
<p>filter()同样接收一个函数和一个序列，然后把传入的函数依次作用于序列的每个元素，<br>
如果传入的函数返回true则保留元素，否则丢弃，最终返回一个Iterator。</p>
<h3 id="sorted">sorted</h3>
<p>sorted()函数就是用来排序的，同时可以自己定义排序的规则。</p>
<h2 id="四大模式">四大模式</h2>
<h3 id="设计模式概念与代码">设计模式概念与代码：</h3>
<p>Python设计模式 设计模式的定义:为了解决面向对象系统中重要和重复的设计封装在一起的一种代码实现框架,<br>
可以使得代码更加易于扩展和调用</p>
<pre><code>from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod#定义抽象方法的关键字
    def pay(self,money):
        pass

    # @abstractmethod
    # def pay(self,money):
    #     raise NotImplementedError

class AiliPay(Payment):
    #子类继承接口,必须实现接口中定义的抽象方法,否则不能实例化对象
    def pay(self,money):
        print('使用支付宝支付%s元'%money)

class ApplePay(Payment):
    def pay(self,money):
        print('使用苹果支付支付%s元'%money)
</code></pre><h3 id="单例模式概念与代码">单例模式概念与代码：</h3>
<p>定义:保证一个类只有一个实例,并提供一个访问它的全局访问点</p>
<pre><code>class Singleton(object):
    #如果该类已经有了一个实例则直接返回,否则创建一个全局唯一的实例
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            cls._instance = super(Singleton,cls).__new__(cls)
        return cls._instance

class MyClass(Singleton):
    def __init__(self,name):
        if name:
            self.name = name

a = MyClass('a')
print(a)
print(a.name)

b = MyClass('b')
print(b)
print(b.name)

print(a)
print(a.name)
</code></pre><h3 id="工厂模式概念与代码">工厂模式概念与代码：</h3>
<p>定义:不直接向客户暴露对象创建的实现细节,而是通过一个工厂类来负责创建产品类的实例</p>
<pre><code>from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    #抽象产品角色
    @abstractmethod
    def pay(self,money):
        pass



class AiliPay(Payment):
    #具体产品角色
    def __init__(self,enable_yuebao=False):
        self.enable_yuebao = enable_yuebao

    def pay(self,money):
        if self.enable_yuebao:
            print('使用余额宝支付%s元'%money)
        else:
            print('使用支付宝支付%s元'%money)

class ApplePay(Payment):
    # 具体产品角色
    def pay(self,money):
        print('使用苹果支付支付%s元'%money)

class PaymentFactory:
    #工厂角色
    def create_payment(self,method):
        if method == 'alipay':
            return AiliPay()
        elif method == 'yuebao':
            return AiliPay(True)
        elif method == 'applepay':
            return ApplePay()
        else:
            return NameError

p = PaymentFactory()
f = p.create_payment('yuebao')
f.pay(100)
</code></pre><h3 id="观察者模式概念与代码">观察者模式概念与代码：</h3>
<p>定义:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,<br>
所有依赖它的对象都会得到通知并被自动更新.观察者模式又称为'发布订阅'模式</p>
<pre><code>from abc import ABCMeta, abstractmethod

#抽象主题
class Oberserver(metaclass=ABCMeta):
    @abstractmethod
    def update(self):
        pass

#具体主题
class Notice:
    def __init__(self):
        self.observers = []

    def attach(self,obs):
        self.observers.append(obs)

    def detach(self,obs):
        self.observers.remove(obs)

    def notify(self):
        for obj in self.observers:
            obj.update(self)

#抽象观察者
class ManagerNotice(Notice):
    def __init__(self,company_info=None):
        super().__init__()
        self.__company_info = company_info

    @property
    def company_info(self):
        return self.__company_info

    @company_info.setter
    def company_info(self,info):
        self.__company_info = info
        self.notify()

#具体观察者
class Manager(Oberserver):
    def __init__(self):
        self.company_info = None
    def update(self,noti):
        self.company_info = noti.company_info

#消息订阅-发送
notice = ManagerNotice()

alex=Manager()
tony=Manager()

notice.attach(alex)
notice.attach(tony)
notice.company_info=&quot;公司运行良好&quot;
print(alex.company_info)
print(tony.company_info)

notice.company_info=&quot;公司将要上市&quot;
print(alex.company_info)
print(tony.company_info)

notice.detach(tony)
notice.company_info=&quot;公司要破产了，赶快跑路&quot;
print(alex.company_info)
print(tony.company_info)
</code></pre>
</div>


    </main>

    
      
    
  </body>
</html>
